数组去重

2023/3/9

手撕代码

使用ES6 Set去重（ES6中常用，但无法去掉{}空对象，因为Set去重的原理是判断两者所处的内存单元位置是否一样，对象是引用类型，当值相同时引用地址不同，故无法去重）Set能去除NaN，用的是和恒等相似的逻辑

function unique(arr){
    return Array.from(new Set(arr));
}
var arr = [1,1,true,true,'true','true',false,false,'false','false',undefined,undefined,null,null,NaN,NaN,0,0,{},{}];
console.log(unique(arr));
//[1, true, 'true', false, 'false', undefined, null, NaN, 0, {}, {}]

利用循环嵌套for，然后splice去重（ES5中最常用，无法去掉NaN和{}，因为NaN不等于任何值，{}在比较的时候比较的是引用地址）

function unique(arr){
    for(let i = 0; i <= arr.length - 1; i++){
        for(let j = i + 1; j <= arr.length - 1; j++)        {
            if(arr[i] === arr[j]){
                arr.splice(j,1);
                j--;
            }
        }
    }
    return arr;
}
var arr = [1,1,true,true,'true','true',false,false,'false','false',undefined,undefined,null,null,NaN,NaN,0,0,{},{}];
console.log(unique(arr));
//[1, true, 'true', false, 'false', undefined, null, NaN, NaN, 0, {}, {}]

使用indexOf去重(仍然是NaN和{}无法去除)

function unique(arr){
    let result = [];
    for(let i = 0; i <= arr.length - 1; i++){
        if(result.indexOf(arr[i]) === -1){
            result.push(arr[i]);
        }
    }
    return result;
}
var arr = [1,1,true,true,'true','true',false,false,'false','false',undefined,undefined,null,null,NaN,NaN,0,0,{},{}];
console.log(unique(arr));
//[1, true, 'true', false, 'false', undefined, null, NaN, NaN, 0, {}, {}]

利用sort()去重(仍然无法去除NaN和{})

function unique(arr){
    arr.sort();
    let result = [arr[0]];
    for(let i = 1; i <= arr.length - 1; i++){
        if(arr[i] != arr[i-1]){
            result.push(arr[i]);
        }
    }
    return result;
}
var arr = [1,1,true,true,'true','true',false,false,'false','false',undefined,undefined,null,null,NaN,NaN,0,0,{},{}];
console.log(unique(arr));
//[0, 1, NaN, NaN, {}, {}, false, 'false', null, true, 'true', undefined]

利用对象键不可以重复的特性去重(这个方式也有问题，因为对象的键只能为string或symbol，在这个过程中，会转换数组成员的类型在进行比较，下例中的键变为：[‘0’, ‘1’, ‘true’, ‘false’, ‘undefined’, ‘null’, ‘NaN’, ‘[object Object]’])

function unique(arr){
    let obj = {};
    arr.forEach((item)=>{
        obj[item] = item;
    })
    return Object.values(obj);
}
var arr = [1,1,true,true,'true','true',false,false,'false','false',undefined,undefined,null,null,NaN,NaN,0,0,{},{}];
console.log(unique(arr));
//[0, 1, 'true', 'false', undefined, null, NaN, {}]

利用includes去重({}没有去重)

function unique(arr){
    let result = [];
    for(let i = 0; i <= arr.length - 1; i++){
        if(!result.includes(arr[i])){
            result.push(arr[i]);
        }
    }
    return result;
}
var arr = [1,1,true,true,'true','true',false,false,'false','false',undefined,undefined,null,null,NaN,NaN,0,0,{},{}];
console.log(unique(arr));
//[1, true, 'true', false, 'false', undefined, null, NaN, 0, {}, {}]

利用hasOwnProperty和filter(filter若return false则丢弃这个数，若return true则保留这个数，去重成功，也可以用key in obj判断，相比于上面的利用键值对去重，这个加了数组项的类型，所以规避了true与“true”去重的弊端)

function unique(arr){
    var obj = {};
    return arr.filter(function(item){
        return obj.hasOwnProperty(typeof item + item)?false:(obj[typeof item+item]=true)
    })
}
var arr = [1,1,true,true,'true','true',false,false,'false','false',undefined,undefined,null,null,NaN,NaN,0,0,{},{}];
console.log(unique(arr));
//[1, true, 'true', false, 'false', undefined, null, NaN, 0, {…}]

LOADING...

数组去重